# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Empresa básica                             ##
 ##                                              ##
 ##                                              ##
 ##                                              ##
 ##   por Críptidos Digitales                    ##
 ##   GPL (c)2009                                ##
  ##                                             ##
    ###############################################

# print (0), "  personas.selector     begin"

from PyQt4 import QtCore, QtGui
import datetime
from man import Entidad, Rol


import selector_ui

import modelo

# print (0), "  personas.selector       definitions"

class Forma(QtGui.QFrame):

    ## Content
    RFC = 1
    TELEFONO = 2

    @property
    def tipo(self):
        return self.__tipo

    def setTipo(self, tipo):
        self.__tipo = tipo
        if tipo==u'proveedores':
            self.__tipoS = u'proveedor'
        elif tipo==u'empleados':
            self.__tipoS = u'empleado'
        elif tipo==u'clientes':
            self.__tipoS = u'cliente'

    @property
    def tipoS(self):
        return self.__tipoS

    def getModo(self):
        return self.__modo


    def __init__(self, *args, **kwds):
        m = "personas.selector.Forma.__init__()"
        # print (1), m

        if kwds.has_key('modo'):
            self.__modo = kwds.pop('modo')
        else:
            self.__modo = None

        self.setTipo(args[1])
        args = (args[0],)

        QtGui.QFrame.__init__(self, *args)

        self.ui = selector_ui.Ui_Form()

        self.ui.setupUi(self)

        self.rol = None

        self.rangosPrecio = modelo.rangosPrecio(activo=True)
        for index, rango in enumerate(self.rangosPrecio):
            if index:
                self.rangosPrecio[index].style = "background-color:#FFFF80;"
            else:
                self.rangosPrecio[index].style = "background-color:#80FF80;"

        self.setRangoPrecioId(modelo.rangoPrecioDefault().id)

        if self.tipo==u'Clientes':
            ## Se carga los clientes al inicio, cualquier actualización se reflejará automáticamente mediante un broadcast.
            self.personaDefault = modelo.rolDefault(u'cliente')
            self.persona = self.personaDefault

        ## Nombre
        font = QtGui.QFont()
        font.setPointSize(10)
        font.setWeight(75)
        font.setBold(True)
        self.ui.edNombre.setFont(font)
        self.ui.edNombre.setCapitalized(True)

        completer = QtGui.QCompleter([], self.ui.edNombre)
        self.modeloNombre = ModeloNombre()
        completer.setModel(self.modeloNombre)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        completer.setWrapAround(False)

        self.ui.edNombre.setCompleter(completer)
        self.ui.edNombre.setStyleSheet("color:#0000FF; background-color:#FFFFFF")

        self.connect(self.ui.edNombre, QtCore.SIGNAL('downArrowPressed()'), self.muestraNombres)
        # self.connect(self.ui.edNombre.completer(), QtCore.SIGNAL('activated(QString)'), self.nombreSeleccionado)
        self.connect(completer, QtCore.SIGNAL('activated(QModelIndex)'), self.nombreSeleccionado)
        self.connect(self.ui.edNombre, QtCore.SIGNAL('textEdited(QString)'), self.nombreEditado)

        self.cargaNombres()

        self.ui.cbNombre.hide()

        ## Apellidos
        completer2 = QtGui.QCompleter([], self.ui.edNombre2)
        self.modeloNombre2 = ModeloNombre2()
        completer2.setModel(self.modeloNombre2)
        completer2.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        completer2.setWrapAround(False)

        self.ui.edNombre2.setCompleter(completer2)
        self.ui.edNombre2.setStyleSheet("color:#0000FF; background-color:#FFFFFF")

        self.connect(completer2, QtCore.SIGNAL("activated(QModelIndex)"), self.nombre2Activado)
        self.connect(self.ui.edNombre2, QtCore.SIGNAL('textEdited(QString)'), self.nombre2Editado)

        self.cargaNombres2()

        ## Calle
        self.ui.edCalle.setAllowedLengths(0, 50)
        self.connect(self.ui.edCalle, QtCore.SIGNAL('editingFinished()'), self.calleCapturada)

        ## Colonia
        self.ui.edAreaNominal.setAllowedLengths(3, 45)
        self.ui.edAreaNominal.setEmptyAllowed(True)
        self.connect(self.ui.edAreaNominal, QtCore.SIGNAL('editingFinished()'), self.coloniaCapturada)

        ## Lugar
        font = QtGui.QFont()
        font.setPointSize(10)
        font.setBold(True)
        self.ui.cbLugar.lineEdit().setFont(font)

        self.connect(self.ui.cbLugar, QtCore.SIGNAL('currentIndexChanged(int)'), self.lugarChanged)
        self.connect(self.ui.cbLugar, QtCore.SIGNAL('lostFocus()'), self.lugarLostFocus)
        self.cargaLugares()

        ## RFC
        rfcCompleter = QtGui.QCompleter([], self.ui.edRFC)
        rfcCompleter.setModel(Modelo(completer))
        rfcCompleter.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edRFC.setCompleter(rfcCompleter)
        self.connect(self.ui.edRFC.completer(), QtCore.SIGNAL('activated(QModelIndex)'), self.rfcSeleccionado)
        self.connect(self.ui.edRFC, QtCore.SIGNAL('textEdited(QString)'), self.rfcEditado)
        self.cargaRfcs()
        if not self.getModo() is None:
            self.ui.edRFC.setModo(self.getModo())

        self.setRfcObligatorio(True)

        ## Rango Precio
        self.connect(self.ui.boRangoPrecio, QtCore.SIGNAL('clicked()'), self.toggleRangoPrecio)


        self.setTabOrder(self.ui.edNombre, self.ui.cbNombre)
        self.setTabOrder(self.ui.cbNombre, self.ui.edNombre2)
        self.setTabOrder(self.ui.edNombre2, self.ui.edCalle)
        self.setTabOrder(self.ui.edCalle, self.ui.edAreaNominal)
        self.setTabOrder(self.ui.edAreaNominal, self.ui.cbLugar)
        self.setTabOrder(self.ui.cbLugar, self.ui.edRFC)
        self.setTabOrder(self.ui.edRFC, self.ui.edTelefono)

        self.__content = 15
        self.changed = False

        self.clear()

        self.old = self.data()


    def calleCapturada(self):
        self.esValido()
        self.emit(QtCore.SIGNAL("clienteEdited()"))
        # self.ui.edAreaNominal.setFocus()


    def cargaNombres(self, mask=''):
        m = "personas.selector.Forma.cargaNombres()"

        if len(mask) > 1:
            roles = modelo.rolesI(tipo=self.tipoS.lower(), nombre=unicode(mask))
        else:
            roles = []

        self.ui.edNombre.completer().model().clear()
        for row, rol in enumerate(roles):
            self.ui.edNombre.completer().model().insertRow(row)
            index = self.ui.edNombre.completer().model().index(row, 0)
            self.ui.edNombre.completer().model().setData(index, QtCore.QVariant("%s (%s)" % (rol.entidad.nombre, rol.entidad.nombre2)), QtCore.Qt.DisplayRole)
            self.ui.edNombre.completer().model().setData(index, QtCore.QVariant(rol.id), QtCore.Qt.UserRole)


    def cargaLugares(self):         # print "personas.selector.Forma.cargaLugares()"
        registros = modelo.lugares()
        self.ui.cbLugar.clear()
        for registro in registros:
            self.ui.cbLugar.addItem(registro.nombre, QtCore.QVariant(registro.id))


    def cargaNombres2(self):        # print "personas.selector.Forma.cargaNombre2()"
        roles = modelo.rolesI(tipo=u'cliente', order=u'nombre2')
        self.modeloNombre2.clear()
        for row, rol in enumerate(roles):
            self.modeloNombre2.insertRow(row)
            index = self.modeloNombre2.index(row, 0)
            self.modeloNombre2.setData(index, QtCore.QVariant("%s (%s)" % (rol.entidad.nombre2, rol.entidad.nombre)), QtCore.Qt.DisplayRole)
            self.modeloNombre2.setData(index, QtCore.QVariant(rol.id), QtCore.Qt.UserRole)
            # print cliente.id, ("%s (%s)" % (cliente.entidad.nombre2, cliente.entidad.nombre)).encode('utf8')


    def cargaRfcs(self):
        roles = modelo.rolesI(tipo=u'cliente')

        model = self.ui.edRFC.completer().model()
        model.removeRows(0, model.rowCount())

        for index, rol in enumerate(roles):
            model.insertRow(index)
            model.setData(model.index(index), QtCore.QVariant(rol.entidad.rfc), QtCore.Qt.DisplayRole)
            model.setData(model.index(index), QtCore.QVariant(rol.entidad.rfc), QtCore.Qt.EditRole)
            model.setData(model.index(index), QtCore.QVariant(rol.id), QtCore.Qt.UserRole)

        # registros = modelo.dameRfcs()
        # if registros:
            # self.ui.edRFC.completer().model().setStringList(registros)


    def clear(self):
        self.ui.edNombre.clear()
        self.ui.edNombre2.clear()
        self.ui.edCalle.clear()
        self.ui.edAreaNominal.clear()
        self.ui.cbLugar.setCurrentIndex(-1)
        self.ui.edRFC.clear()
        self.ui.edTelefono.clear()

        self.changed = False
        self.id = None


    def coloniaCapturada(self):
        self.esValido()
        self.emit(QtCore.SIGNAL("clienteEdited()"))


    def content(self):
        return self.__content


    def data(self):                 # print "personas.selector.Forma.data()"
        datos = {}
        datos['nombre'] = unicode(self.ui.edNombre.text().trimmed())
        datos['nombre2'] = unicode(self.ui.edNombre2.text().trimmed())
        datos['fechanacimiento'] = datetime.date(1,1,1)
        datos['personalidad'] = self.ui.edRFC.tipo()
        datos['rfc'] = unicode(self.ui.edRFC.text().trimmed())
        datos['tipo'] = u"trabajo"
        datos['calle'] = unicode(self.ui.edCalle.text().trimmed())
        datos['areanominal']  = unicode(self.ui.edAreaNominal.text().trimmed())
        datos['areapostal'] = unicode("")
        datos['rangoprecio'] = self.rangoPrecio

        if self.ui.cbLugar.currentIndex() == -1:
            datos['lugar'] = unicode(self.ui.cbLugar.currentText())
        else:
            datos['lugar_id'] = self.ui.cbLugar.itemData(self.ui.cbLugar.currentIndex()).toInt()[0]

        datos['telefonoFijo'] = unicode(self.ui.edTelefono.text().trimmed())

        return datos


    @property
    def esRfcObligatorio(self):
        return self.__rfcObligatorio


    def esValido(self):
        m = "personas.selector.Forma.esValido()"

        # print (1), m

        valida = True
        self.mensajes = u""

        if self.ui.edNombre.text() == "":
            valida = False
            self.mensajes += u"Falta el nombre\n"

        if not self.ui.edCalle.isValid:
            valida = False
            self.mensajes += u"%s en la calle\n" % self.ui.edCalle.message()

        if not self.ui.edAreaNominal.isValid:
            valida = False
            self.mensajes += u"%s en la colonia\n" % self.ui.edAreaNominal.message()

        # if not self.ui.edLugar.isValid:
            # valida = False
            # self.mensajes += u"%s en el lugar\n" % self.ui.edLugar.message()

        if self.ui.edRFC.isVisible() and not self.ui.edRFC.isValid:
            if self.esRfcObligatorio:
                valida = False
                if self.ui.edRFC.text() == '':
                    self.mensajes += u"Falta el RFC\n"
                else:
                    self.mensajes += u"Error en el RFC\n"
            else:
                if self.ui.edRFC.text() != '':
                    self.mensajes += u"Error en el RFC\n"



        # self.rol = modelo.rolI(tipo=self.tipoS, nombre=unicode(self.ui.edNombre.text().trimmed()), nombre2=unicode(self.ui.edNombre2.text().trimmed()), rfc=unicode(self.ui.edRFC.text().trimmed()))
        # print (1), m, valida, self.mensajes

        return valida


    def guarda(self):
        print "personas.selector.Forma.guarda()"

        f=g

        datos = self.data()

        lugar = modelo.dameLugar(nombre=datos['lugar'])
        if not lugar:
            modelo.agregaLugar(datos['lugar'])
            self.emit(QtCore.SIGNAL("lugaresChanged()"))

        filtros = {'nombre':datos['nombre'], 'nombre2':datos['nombre2']}
        if datos['rfc']:
            filtros['rfc'] = datos['rfc']

        self.rol = modelo.rolI(tipo=self.tipoS, **filtros)
        if not self.rol:
            # Falta checar que sea una entidad que ya existe y solo se agregaria el rol
            self.rol = modelo.agrega(datos)
            self.emit(QtCore.SIGNAL("clientesChanged()"))


    # def lugarSeleccionado(self, texto): # print "clientes.selectorCliente.Forma.lugarSeleccionado()"
        # self.ui.edLugar.setText(texto)
        # self.emit(QtCore.SIGNAL("clienteEdited()"))


    # def muestraLugares(self):
        # self.ui.edLugar.completer().setCompletionPrefix(self.ui.edLugar.text())
        # self.ui.edLugar.completer().complete()


    def lugarChanged(self):
        self.emit(QtCore.SIGNAL('clienteEdited()'))


    def lugarLostFocus(self):
        self.ui.cbLugar.setCurrentIndex(self.ui.cbLugar.findText(self.ui.cbLugar.currentText(), QtCore.Qt.MatchStartsWith))


    def muestraNombres(self):
        self.ui.edNombre.completer().complete()


    def nombreEditado(self, mask=""):
        m = "personas.selector.Forma.nombreEditado()"

        if self.ui.edNombre2.text():
            self.ui.edRFC.setTipo(self.ui.edRFC.FISICA)
        else:
            self.ui.edRFC.setTipo(self.ui.edRFC.MORAL)

        self.cargaNombres(mask)

        self.ui.edNombre.completer().model().reset()


    def nombreSeleccionado(self, completerModelIndex):
        m = "personas.selector.Forma.nombreSeleccionado()"
        # print (1), m

        rol = modelo.rolI(id=self.ui.edNombre.completer().completionModel().data(completerModelIndex, QtCore.Qt.UserRole).toInt()[0])

        self.setData(rol)

        self.emit(QtCore.SIGNAL("clienteSelected()"))


    def nombre2Editado(self, texto):# print "personas.selector.Forma.nombre2Editado()"
        if self.ui.edNombre2.text():
            self.ui.edRFC.setTipo(self.ui.edRFC.FISICA)
        else:
            self.ui.edRFC.setTipo(self.ui.edRFC.MORAL)

        # self.rol = modelo.rolI(tipo=self.tipoS, nombre=texto, nombre2=unicode(self.ui.edNombre2.text()), rfc=unicode(self.ui.edRFC.text()))

        # self.emit(QtCore.SIGNAL("clienteEdited()"))
        # self.ui.edNombre2.setFocus()


    def nombre2Activado(self, completerModelIndex):
        m = "personas.selector.Forma.nombre2Activado()"
        # print (1), m

        rol = modelo.rolI(id=self.ui.edNombre2.completer().completionModel().data(completerModelIndex, QtCore.Qt.UserRole).toInt()[0])

        self.setData(rol)

        self.emit(QtCore.SIGNAL("clienteSelected()"))


    @property
    def rangoPrecioId(self):
        return self.__rangoPrecio


    def rfcEditado(self, texto):
        self.esValido()
        self.emit(QtCore.SIGNAL("clienteEdited()"))


    def rfcSeleccionado(self, index): # print "personas.selector.Forma.rfcSeleccionado()"
        rol = modelo.rolI(id=self.ui.edRFC.completer().completionModel().data(index, QtCore.Qt.UserRole).toInt()[0])
        self.setData(rol)


    def setContent(self, value):
        self.__content = value
        if self.__content & self.RFC:
            self.ui.laRFC.show()
            self.ui.edRFC.show()
        else:
            self.ui.laRFC.hide()
            self.ui.edRFC.hide()
        if self.__content & self.TELEFONO:
            self.ui.laTelefono.show()
            self.ui.edTelefono.show()
        else:
            self.ui.laTelefono.hide()
            self.ui.edTelefono.hide()


    def setData(self, rol):
        m = "personas.selector.Forma.setData()"
        # print (1), m, rol

        self.ui.edNombre.setText("%s" % rol.entidad.nombre)
        self.ui.edNombre2.setText("%s" % rol.entidad.nombre2)
        self.ui.edCalle.setText(rol.direcciones[0].calle)
        self.ui.edAreaNominal.setText("%s" % rol.direcciones[0].areanominal)

        if rol.direcciones[0].lugar_id:
            self.ui.cbLugar.setCurrentIndex(self.ui.cbLugar.findData(QtCore.QVariant(rol.direcciones[0].lugar_id)))

        self.ui.edRFC.setText(rol.entidad.rfc)

        self.rol = rol

        self.ui.edRFC.setTipo(self.rol.entidad.personalidad)

        rangoPrecioZero = [x for x in rol.atributos if x.nombre==u'rangoPrecio']
        if rangoPrecioZero:
            if rangoPrecioZero[0].id != self.rangoPrecioId:
                self.setRangoPrecio(rangoPrecioZero[0].id)

        self.old = self.data()


    def setDataa(self, data):
        m = "personas.selector.Forma.setDataa()"
        # print (1), m

        if 'nombre' in data.keys():
            self.ui.edNombre.setText("%s" % data['nombre'])
        if 'nombre2' in data.keys():
            self.ui.edNombre2.setText("%s" % data['nombre2'])
        if 'calle' in data.keys():
            self.ui.edCalle.setText(data['calle'])
        if 'areanominal' in data.keys():
            self.ui.edAreaNominal.setText("%s" % data['areanominal'])
        if 'lugar' in data.keys():
            if self.ui.cbLugar.findText(data['lugar']):
                self.ui.cbLugar.setCurrentIndex(self.ui.cbLugar.findText(data['lugar']))
            else:
                self.ui.cbLugar.setEditText(data['lugar'])
        if 'rfc' in data.keys():
            self.ui.edRFC.setText(data['rfc'])
        if data['nombre2']:
            self.ui.edRFC.setTipo(self.ui.edRFC.FISICA)
        else:
            self.ui.edRFC.setTipo(self.ui.edRFC.MORAL)

        # rangoPrecioZero = [x for x in rol.atributos if x.nombre==u'rangoPrecio']
        # if rangoPrecioZero:
            # if rangoPrecioZero[0].id != self.rangoPrecioId:
                # self.setRangoPrecio(rangoPrecioZero[0].id)

        self.old = self.data()


    def setRangoPrecioId(self, rangoId):
        self.rangoPrecio = rangoId
        rango = [x for x in self.rangosPrecio if x.id==rangoId][0]
        self.ui.boRangoPrecio.setStyleSheet(rango.style)
        self.emit(QtCore.SIGNAL('rangoPrecioSelected(int)'), rangoId)


    def setRfcObligatorio(self, value):
        self.__rfcObligatorio = value
        if value == True:
            self.ui.edRFC.setEmptyAllowed(False)
        else:
            self.ui.edRFC.setEmptyAllowed(True)


    def toggleRangoPrecio(self):
        print "personas.selector.Forma.toggleRangoPrecio()"
        rango = [x for x in self.rangosPrecio if x.id==self.rangoPrecio][0]
        rango = [x for x in self.rangosPrecio if x.id!=rango.id][0]
        self.setRangoPrecioId(rango.id)


class Modelo(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []

    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.endRemoveRows()

    def data(self, index, role=QtCore.Qt.DisplayRole):  # print "productos.igu.Modelo.data()"
        if index.row() != -1:
            if role in [QtCore.Qt.DisplayRole]:
                return self.__data[index.row()][0]
            elif role in [QtCore.Qt.EditRole]:
                return self.__data[index.row()][1]
            elif role == QtCore.Qt.TextAlignmentRole:
                return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
            elif role == QtCore.Qt.UserRole:
                return self.__data[index.row()][2]
        return QtCore.QVariant()

    def insertRow(self, row, parent=QtCore.QModelIndex()):  # print "productos.igu.Modelo.insertRow()"
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True

    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)

    def reload(self):
        pass

    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role == QtCore.Qt.DisplayRole:
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.EditRole:
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            self.__data[index.row()][2] = QtCore.QVariant(valor)
        else:
            print 12345, role
        return True




class ModeloNombre(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):
        # print "personas.selector.ModeloNombre.data()"

        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            # print "DisplayRole"
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            # print "TextAlignmentRole"
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == QtCore.Qt.UserRole:
            # print "UserRole"
            return self.__data[index.row()][1]
        else:
            # print role
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):  # print "personas.selector.ModeloNombre.insertRow()"
        self.beginInsertRows(QtCore.QModelIndex(), row, row)
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u"")])
        self.endInsertRows()
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def reload(self):
        pass


    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):

        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True



class ModeloNombre2(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):  # print "personas.selector.ModeloNombre2.data()"
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            # print "DisplayRole"
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            # print "TextAlignmentRole"
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == QtCore.Qt.UserRole:
            # print "UserRole"
            return self.__data[index.row()][1]
        else:
            # print role
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):  # print "personas.selector.ModeloNombre2.insertRow()"
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def reload(self):
        pass


    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True



# print (0), "  personas.selector     end"


"""
Iniciación
    Se carga el rol default

Para alta rápida de rol
    Al cambiar el nombre o apellido en sus correspondientes casos, se asume
    que se está capturando un rol nuevo y se limpia el resto de los campos.
    Revisar si ya existe la entidad





"""

